/**
 * 暗黑破坏神2重置版数据服务
 * 提供本地数据访问和云数据库兼容层
 */
import items from './items.js'
import builds from './builds.js'
import classes from './classes.js'
import runes from './runes.json'
import runewords from './runewords.json'
import { runeDrops } from './rune-drops.js'
import runeUpgrades from './rune-upgrades.json'
// import { getEnv } from '../envConfig.js';

// 数据缓存
const dataCache = {
  items: null,
  builds: null,
  classes: null,
  runes: null,
  runewords: null,
  runeDrops: null,
  lastUpdate: null
}

// 缓存过期时间（毫秒）
const CACHE_EXPIRE_TIME = 24 * 60 * 60 * 1000 // 24小时

/**
 * 过滤本地数据
 */
function filterData(data, query = {}, options = {}) {
  if (!data) return []
  console.log('filterData', data)
  
  // 确保数据是数组
  if (!Array.isArray(data)) {
    console.warn('filterData: data is not iterable, using empty array', data)
    return []
  }
  
  // 应用查询条件
  let result = [...data]
  if (query) {
    result = result.filter(item => {
      return Object.keys(query).every(key => {
        // 简单相等查询
        if (typeof query[key] !== 'object') {
          return item[key] === query[key]
        }

        // 复杂查询（模拟MongoDB查询操作符）
        const queryObj = query[key]

        // $eq 等于
        if (queryObj.$eq !== undefined) {
          return item[key] === queryObj.$eq
        }

        // $gt 大于
        if (queryObj.$gt !== undefined) {
          return item[key] > queryObj.$gt
        }

        // $gte 大于等于
        if (queryObj.$gte !== undefined) {
          return item[key] >= queryObj.$gte
        }

        // $lt 小于
        if (queryObj.$lt !== undefined) {
          return item[key] < queryObj.$lt
        }

        // $lte 小于等于
        if (queryObj.$lte !== undefined) {
          return item[key] <= queryObj.$lte
        }

        // $in 包含
        if (queryObj.$in !== undefined) {
          return queryObj.$in.includes(item[key])
        }

        // $regex 正则匹配
        if (queryObj.$regex !== undefined) {
          const regex = new RegExp(queryObj.$regex, queryObj.$options || '')
          return regex.test(item[key])
        }

        return true
      })
    })
  }

  // 应用排序
  if (options.sort) {
    const { field, order = 'desc' } = options.sort
    result.sort((a, b) => {
      if (order.toLowerCase() === 'asc') {
        return a[field] > b[field] ? 1 : -1
      } else {
        return a[field] < b[field] ? 1 : -1
      }
    })
  }

  // 应用分页
  if (options.offset !== undefined || options.limit !== undefined) {
    const offset = options.offset || 0
    const limit = options.limit || result.length
    result = result.slice(offset, offset + limit)
  }

  return result
}

/**
 * 加载本地数据
 */
async function loadLocalData(collection, query = {}, options = {}) {
  // 加载数据
  let data
  switch (collection) {
    case 'items':
      data = items
      break
    case 'builds':
      data = builds
      break
    case 'classes':
      data = classes
      break
    case 'runes':
      data = runes
      break
    case 'runewords':
      data = runewords
      break
    case 'runeDrops':
      data = runeDrops
      break
    case 'rune-upgrades':
      data = runeUpgrades
      break
    default:
      throw new Error(`未知的集合: ${collection}`)
  }
  console.log(`[loadLocalData] 加载本地数据 ${collection}`, data)

  // 处理对象格式的数据（仅当需要数组时转换）
  if (collection !== 'runeDrops' && data && typeof data === 'object' && !Array.isArray(data)) {
    data = Object.values(data)
  }

  // 对于 runeDrops，直接返回原始数据对象
  if (collection === 'runeDrops') {
    return data
  }

  return filterData(data, query, options)
}

/**
 * 统一数据加载接口
 * @param {String} collection 集合名称：items/builds/classes
 * @param {Object} query 查询条件
 * @param {Object} options 选项：limit/offset/sort
 * @returns {Promise} 数据结果
 */
export async function loadData(collection, query = {}, options = {}) {
  // // 检查环境
  // const env = getEnv();

  // console.log('env', env)
  // // 生产环境且配置了云开发
  // if (env === 'production' && uni.cloud) {
  //   return loadCloudData(collection, query, options);
  // }

  // 开发环境或未配置云开发，使用本地数据
  return loadLocalData(collection, query, options)
}

/**
 * 加载云数据
 */
async function loadCloudData(collection, query = {}, options = {}) {
  try {
    const db = uni.cloud.database()
    const dbCollection = db.collection(collection)

    // 构建查询
    let dbQuery = dbCollection

    // 应用查询条件
    if (query) {
      Object.keys(query).forEach(key => {
        dbQuery = dbQuery.where({
          [key]: query[key]
        })
      })
    }

    // 应用排序
    if (options.sort) {
      dbQuery = dbQuery.orderBy(options.sort.field, options.sort.order || 'desc')
    }

    // 应用分页
    if (options.limit) {
      dbQuery = dbQuery.limit(options.limit)
    }

    if (options.offset) {
      dbQuery = dbQuery.skip(options.offset)
    }

    // 执行查询
    const res = await dbQuery.get()
    return res.data
  } catch (e) {
    console.error('云数据库查询失败', e)
    // 失败时回退到本地数据
    return loadLocalData(collection, query, options)
  }
}

/**
 * 更新收藏计数
 */
export async function updateFavorite(collection, id, increment = true) {
  // 检查环境
  const env = getEnv()

  // 生产环境且配置了云开发
  if (env === 'production' && uni.cloud) {
    try {
      const db = uni.cloud.database()
      const _ = db.command

      await db
        .collection(collection)
        .doc(id)
        .update({
          data: {
            favCount: _.inc(increment ? 1 : -1)
          }
        })

      return true
    } catch (e) {
      console.error('云数据库更新失败', e)
      return false
    }
  }

  // 开发环境或未配置云开发，使用本地数据
  if (!dataCache[collection]) {
    await loadLocalData(collection)
  }

  const index = dataCache[collection].findIndex(item => item._id === id)
  if (index !== -1) {
    dataCache[collection][index].favCount =
      (dataCache[collection][index].favCount || 0) + (increment ? 1 : -1)

    // 更新本地存储
    try {
      uni.setStorage({
        key: `d2r_${collection}`,
        data: {
          data: dataCache[collection],
          timestamp: Date.now()
        }
      })
    } catch (e) {
      console.error('本地缓存更新失败', e)
    }

    return true
  }

  return false
}

export default {
  loadData,
  updateFavorite
}
